package ThinkInJava;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Foundation {

	public static void main(String[] args) {
		//对于未指定List初始长度的构造方法，初始长度是10
		List<Integer> list=new ArrayList<>();
		List<Integer> list1=new ArrayList<>(20);  //指定初始长度是20
		Collections.synchronizedList(list);  //同步
//		验证初始化顺序
		Foundation dFoundation=new Foundation();
//		dFoundation.testmethhod();
		
//		验证== 和equal方法
		int i=0;
		Integer m= new Integer(0);
		Integer j = new Integer(0);
		Integer n=1;  //自动装箱
		Integer k=Integer.valueOf(1);  //通过valueOf方法创建一个对象
		
//		System.out.println(m==j);  //两个Integer对象，比较的是引用的值
//		System.out.println(j.equals(m));  //Integer调用equals方法是是比较的值
//		System.out.println(n==k);     //由于有一个IntegerCache 故这两个的引用实际上相等
//		System.out.println(i==j);    //当Integer与int数据类型比较时会自动拆箱
//		System.out.println(j.equals(i));   //比较值
		System.out.println(j.equals(0));  //在equal方法中判断参数是不是Integer的类型，9是整数类型，故为true
		
		dFoundation.testM();
	}
	void threadMethod(){
		Thread thread=new Thread();
		thread.start();
	}
	void testM(){
		boolean m=true;
		boolean n=true;
		m=!n;   //对于boolean数据的逻辑运算，即 ！，| ，&，就是非，或，与运算
		System.out.println(m);
	}
	void testmethhod(){
//		int x;   //局部变量必须在申明的时候初始化
//		System.out.println(x);  
		A a=new B();
		a.prin();
		String mmString=" hhh"; //在java7 中可以使用字符串作为参数
		//float mmm=3.25;    //但是不能使用浮点型的数据
		// Only convertible int values, strings or enum variables are permitted
		switch (mmString) {
		case "kkk":
			
			break;

		default:
			break;
		}
	}
	
	class Base{
		public Base(String mm) {
			System.out.println("no "+mm);
		}
		public void bbb() {
		}
	}
	class Test extends Base{
		String empId="ddd";
		//子类构造之前必须构造父类，若父类有无参的构造函数（不管是默认的还是自己定义的无参的构造函数），
		//则调用无参的构造函数，若没有，则需要子类明确调用父类的构造函数,而且必须放在第一句
		public Test(String id) {
			super(id);
			empId=id;
		}
		public Test() {
			super("id");
//			this("id");   //调用其他构造方法的this()也必须放在第一行，因此无论把哪个放在第一行，都是会报错的
			              //也就是说this 和super不能出现在同一个构造函数中
		}
		//Cannot define static initializer in inner type Foundation.Test
		//为什么不能定义内部类的静态代码块？
		
	}
	
	interface C{
		int i=0;
		void AAAA();  //public & abstract are permitted
	}
	
	class A{
		void prin(){
			System.out.println("Base");
		}
	}
	class  B extends A{
		//Cannot reduce the visibility of the inherited method from Foundation.A
		//当父类的方法对子类不可见（包权限但是不在一个包里面，另外就是private 是不能重写的）
		@Override
	    public void prin() {
			//super.prin();
			System.out.println("son");
		}
		void ggg(){
			System.out.println("hhhh");
		}
	}
}
